// #define _GNU_SOURCE
// 先不用这个玩意 但为啥要用这个呢
#define _GNU_SOURCE //提供了一些GNU扩展功能的支持
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <errno.h>
#include <string.h>
#include <signal.h>
#include <termios.h>


typedef struct uart_hardware_cfg {
    unsigned int baudrate;  /* 波特率*/
    unsigned char dbit;     /* 数据位*/
    char parity;            /* 奇偶校验*/
    unsigned char sbit; /* 停止位 */
}uart_cfg_t;

static struct termios old_cfg; //用于保存终端的配置参数
static int fd; //串口终端对应的文件描述符

static int uart_init(const char* device)
{
    /* 打开串口终端 */
    //O_NOCTTY:不加这个之后，任何输入输出就会被进程打断了； 
    fd = open(device, O_RDWR | O_NOCTTY);
    if(0 > fd) {
        fprintf(stderr,"open error:%s:%s\n",device,strerror(errno));
        return -1;
    }

     /* 获取串口当前的配置参数 */
    if (0 > tcgetattr(fd, &old_cfg)) {
        fprintf(stderr, "tcgetattr error: %s\n", strerror(errno));
        close(fd);
        return -1;
    }
    return 0;
}
/**
 * 串口配置
 * cfg 结构体对象
 * **/
// 输入cfg（自定义类型） 设定一个新的new_cfg.c（linux下的要用的）
// 
static int uart_cfg(const uart_cfg_t *cfg)
{
    struct termios new_cfg = {0}; //将 new_cfg 对象清零
    speed_t speed;
    /* 设置为原始模式 */
    cfmakeraw(&new_cfg);

     /* 使能接收 */
    new_cfg.c_cflag |= CREAD;

    // 使能发送
    // new_cfg.c_cflag &= ~CLOCAL;
     /* 设置波特率 */
    switch (cfg->baudrate) {
        case 1200: speed = B1200;
                    break;
        case 1800: speed = B1800;
                    break;
        case 2400: speed = B2400;
                    break;
        case 4800: speed = B4800;
                    break;
        case 9600: speed = B9600;
                    break;
        case 19200: speed = B19200;
                    break;
        case 38400: speed = B38400;
                    break;
        case 57600: speed = B57600;
                    break;
        case 115200: speed = B115200;
                    break;
        case 230400: speed = B230400;
                    break;
        case 460800: speed = B460800;
                    break;
        case 500000: speed = B500000;
                    break;
        default: //默认配置为 115200
            speed = B115200;
        printf("default baud rate: 115200\n");
        break;
    }
    if (0 > cfsetspeed(&new_cfg, speed)) {
        fprintf(stderr, "cfsetspeed error: %s\n", strerror(errno));
        return -1;
    }

     /* 设置数据位大小 */
    new_cfg.c_cflag &= ~CSIZE; //将数据位相关的比特位清零

    switch (cfg->dbit) {
        case 5:
            new_cfg.c_cflag |= CS5;
            break;
        case 6:
            new_cfg.c_cflag |= CS6;
            break;
        case 7:
            new_cfg.c_cflag |= CS7;
            break;
        case 8:
            new_cfg.c_cflag |= CS8;
            break;
        default: //默认数据位大小为 8
            new_cfg.c_cflag |= CS8;
            printf("default data bit size: 8\n");
            break;
    }
    /* 设置奇偶校验 */
    switch (cfg->parity) {
    case 'N': //无校验
        new_cfg.c_cflag &= ~PARENB;
        new_cfg.c_iflag &= ~INPCK;
        break;
    case 'O': //奇校验
        new_cfg.c_cflag |= (PARODD | PARENB);
        new_cfg.c_iflag |= INPCK;
        break;
    case 'E': //偶校验
        new_cfg.c_cflag |= PARENB;
        new_cfg.c_cflag &= ~PARODD; /* 清除 PARODD 标志，配置为偶校验 */
        new_cfg.c_iflag |= INPCK;
        break;
    default: //默认配置为无校验
        new_cfg.c_cflag &= ~PARENB;
        new_cfg.c_iflag &= ~INPCK;
        printf("default parity: N\n");
        break;
    }
    /* 设置停止位 */
    switch (cfg->sbit) {

    case 1: //1 个停止位
        new_cfg.c_cflag &= ~CSTOPB;
        break;
    case 2: //2 个停止位
        new_cfg.c_cflag |= CSTOPB;
        break;
    default: //默认配置为 1 个停止位
        new_cfg.c_cflag &= ~CSTOPB;
        printf("default stop bit size: 1\n");
        break;
    }
    /* 将 MIN 和 TIME 设置为 0 */
    // 这个意味着有输入就直接触发了
    new_cfg.c_cc[VTIME] = 0;
    new_cfg.c_cc[VMIN] = 0;

    /* 清空缓冲区 */
    if (0 > tcflush(fd, TCIOFLUSH)) {
        fprintf(stderr, "tcflush error: %s\n", strerror(errno));
        return -1;
    }
    /* 写入配置、使配置生效 */
    if (0 > tcsetattr(fd, TCSANOW, &new_cfg)) {
        fprintf(stderr, "tcsetattr error: %s\n", strerror(errno));
        return -1;
    }
    /* 配置 OK 退出 */
    return 0;
}

/**
 * 信号处理函数 串口有数据可读会跳转该函数执行
 * */
// 因为表明了要给中断处理函数多传入信息
// 
static void io_handler(int sig,siginfo_t *info,void* context)
{
    unsigned char buf[10] = {0};
    int ret;
    int n;
    if(SIGRTMIN != sig) {
        return;
    }
    /* 判断串口是否有数据可读*/
    if(POLL_IN == info->si_code) {
        ret = read(fd,buf,8);
        printf("[");
        for (n = 0; n < ret; n++)
            printf("0x%hhx ", buf[n]);
        printf("]\n");
    }
    // 判断串口是否有数据可发送
    else if (info->si_code == POLL_OUT) {
        // 模拟发送数据，这里可以根据实际情况进行串口发送操作
        buf[0] = 0xAA;
        buf[1] = 0xBB;
        buf[2] = 0xCC;
        ret = write(fd, buf, 3); // 实际应用中可以根据实际发送的数据长度修改

        if (ret == -1) {
            perror("write");
            // 处理发送错误
        } else {
            printf("Sent data: [ ");
            for (n = 0; n < ret; n++)
                printf("0x%hhx ", buf[n]);
            printf("]\n");
        }
    }
}

/**
** 异步 I/O 初始化函数
**/
static void async_io_init(void)
{
    struct sigaction sigatn;
    int flag;
    flag = fcntl(fd,F_GETFL);
    flag |= O_ASYNC;
    fcntl(fd,F_SETFL,flag);

    /* 设置异步 I/O 的所有者 */
    fcntl(fd, F_SETOWN, getpid());
    /* 指定实时信号 SIGRTMIN 作为异步 I/O 通知信号 */
    fcntl(fd, F_SETSIG, SIGRTMIN);

     /* 为实时信号 SIGRTMIN 注册信号处理函数 */
    sigatn.sa_sigaction = io_handler; //当串口有数据可读时，会跳转到 io_handler 函数
    sigatn.sa_flags = SA_SIGINFO;   //它告诉系统在调用信号处理函数时，要传递额外的信息
    sigemptyset(&sigatn.sa_mask);
    sigaction(SIGRTMIN, &sigatn, NULL);
}
int main(int argc, char* argv[])
{
    uart_cfg_t cfg = {0};
    char *device = NULL;
    int rw_flag = -1;
    unsigned char w_buf[10] = {0x11, 0x22, 0x33, 0x44,
    0x55, 0x66, 0x77, 0x88}; //通过串口发送出去的数据
    int n;
    /* 解析出参数 */
    for (n = 1; n < argc; n++) {
        if (!strncmp("--dev=", argv[n], 6))
            device = &argv[n][6];
        else if (!strncmp("--brate=", argv[n], 8))
            cfg.baudrate = atoi(&argv[n][8]);
        else if (!strncmp("--dbit=", argv[n], 7))
            cfg.dbit = atoi(&argv[n][7]);
        else if (!strncmp("--parity=", argv[n], 9))
            cfg.parity = argv[n][9];
        else if (!strncmp("--sbit=", argv[n], 7))
            cfg.sbit = atoi(&argv[n][7]);
        else if (!strncmp("--type=", argv[n], 7)) {
            if (!strcmp("read", &argv[n][7]))
                rw_flag = 0; //读
            else if (!strcmp("write", &argv[n][7]))
                rw_flag = 1; //写
        }
    }

    if (NULL == device || -1 == rw_flag) {
        fprintf(stderr, "Error: the device and read|write type must be set!\n");
        exit(EXIT_FAILURE);
    }
    /* 串口初始化 */
    if (uart_init(device))
        exit(EXIT_FAILURE);
    /* 串口配置 */
    if (uart_cfg(&cfg)) {
        tcsetattr(fd, TCSANOW, &old_cfg); //恢复到之前的配置
        close(fd);
        exit(EXIT_FAILURE);
    }
    /* 读|写串口 */
    switch (rw_flag) {
        case 0: //读串口数据
            async_io_init(); //我们使用异步 I/O 方式读取串口的数据，调用该函数去初始化串口的异步 I/O
            for ( ; ; )
                sleep(1); //进入休眠、等待有数据可读，有数据可读之后就会跳转到 io_handler()函数
        break;
    case 1: //向串口写入数据
        for ( ; ; ) { //循环向串口写入数据
            //直接写入啊
            write(fd, w_buf, 8); //一次向串口写入 8 个字节
            sleep(1); //间隔 1 秒钟
        }
        break;
    }
    /* 退出 */
    tcsetattr(fd, TCSANOW, &old_cfg); //恢复到之前的配置
    close(fd);
    exit(EXIT_SUCCESS);

}